#pragma once // 防止头文件被重复包含
//保证线程安全的环形队列容器
#include <vector>
#include <semaphore.h>
#include <pthread.h>
 
 #define C_MAX 300 //容器的容量

template <class T>
class annular
{
 
public:
    annular(int max_c = C_MAX)
        : max_capacity(max_c), min_capacity(0), _c_subscript(0), _p_subscript(0)
    {
        _v.reserve(max_c);
      
        pthread_mutex_init(&_c_lock, nullptr);
        pthread_mutex_init(&_p_lock, nullptr);
        sem_init(&_c_sem, 0, 0);
        sem_init(&_p_sem, 0, max_c);
    }
 
    ~annular()
    {
        pthread_mutex_destroy(&_c_lock);
        pthread_mutex_destroy(&_p_lock);
        sem_destroy(&_c_sem);
        sem_destroy(&_p_sem);
    }
 
    void push(const T &data)
    {
        sem_wait(&_p_sem);            // 信号量的p操作
        pthread_mutex_lock(&_p_lock); // 加锁
 
        _v[_p_subscript] = data;
        _p_subscript++;
        _p_subscript %= max_capacity;
 
        sem_post(&_c_sem);              // 信号量的v操作
        pthread_mutex_unlock(&_p_lock); // 解锁
    }
 
    void pop(T &data)
    {
        sem_wait(&_c_sem);            // 信号量的p操作
        pthread_mutex_lock(&_c_lock); // 加锁
 
        data = _v[_c_subscript];
        _c_subscript++;
        _c_subscript %= max_capacity;
 
        sem_post(&_p_sem);              // 信号量的v操作
        pthread_mutex_unlock(&_c_lock); // 解锁
    }
 
private:
    pthread_mutex_t _c_lock; // 消费者互斥量
    pthread_mutex_t _p_lock; // 生产者互斥量
    sem_t _c_sem;            // 消费者信号量
    sem_t _p_sem;            // 生产者信号量
    int _c_subscript;        // 消费者下标
    int _p_subscript;        // 生产者下标
    std::vector<T> _v;
    int max_capacity; // 容器最大容量
    int min_capacity; // 容器最小容量
};